home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 050 / xrf.arc / SPOOL.C < prev    next >
Encoding:
C/C++ Source or Header  |  1986-04-20  |  9.1 KB  |  217 lines
  1. /*                MSDOS print spooler interface spool.c                     */
  2. /*                                                                          */
  3. /*  Mike Cole  Digital Equipment Co. Ltd.           3 Jan 85                */
  4. /*  based on PC/MSDOS Tips from Tom Jennings (indirectly).                  */
  5. /*                                                                          */
  6. /*  spool(filename)   adds a 'filename' to print queue.                     */
  7. /*                    return 1 if couldn't queue                            */
  8. /*                           0 if done                                      */
  9. /*                          -1 if error                                     */
  10. /*  unspool(filename) deletes 'filename' from print queue.                  */
  11. /*                    return 0 if done                                      */
  12. /*                          -1 if error                                     */
  13. /*  qspool(namelist)  updates 'namelist' with names in the queue            */
  14. /*                    (starting with the currently printing file.           */
  15. /*                    This will NOT be in queue order.                      */
  16. /*                    return 0..10 as number of 'filenames' in queue.       */
  17. /*                                                                          */
  18. /*  'filename'    char filename[13] as 'filename.sfx',0                     */
  19. /*  'namelist'    char namelist[10][13] each as 'filename.sfx',0            */
  20. /****************************************************************************/
  21. /*   To access DOS' PRINT capabilities:                                     */
  22. /*   MOV AH,func                                                            */
  23. /*   INT 2Fh                                                                */
  24. #define ADD 0x0000        /* AH = 0 adds the file specified by DS:DX to     */
  25.                           /* the print queue.                               */
  26.                           /* DS:DX must point toalid opened FCB.          */
  27. #define CAN 0x0100        /* AH = 1 cancels the file indicated by DS:DX.    */
  28.                           /* DS:DX must point to an FCB, opened or unopened.*/
  29.                           /* The drive byte must not be 0.                  */
  30.                           /* Wildcards are restricted: ? is okay, * isn't.  */
  31. #define QRY 0x0200        /* AH > 1 do nothing.                             */
  32. /****************************************************************************/
  33. /*        Return with registers set as follows:                             */
  34. /*                                                                          */
  35. /*          DS,SI,DI,CX preserved, all others destroyed.                    */
  36. /*          AH = number of files currently in queue.                        */
  37. /*          AL = for AH=0, return 1 if queue was                            */
  38. /*               full.  For all other cases, return 0.                      */
  39. /*          ES:BX = pointer to list of 10 entries in queue.                 */
  40. /*                  each entry is 40 bytes:-                                */
  41. /*                    2  byte queue ordering pointer (ignored by us).       */
  42. /*                       if 1st byte is oxFF, do next??                     */
  43. /*                       else is offset of next entry.                      */
  44. /*                    38 byte FCB. If the first byte of an FCB              */
  45. /*                       FCB is 0xFF, that entry is unused.                 */
  46. /*          ES:DX = pointer to currently printing                           */
  47. /*                  FCB.  If the queue is empty, DX = -1.                   */
  48. /****************************************************************************/
  49. #define TRUE       1
  50. #define FALSE      0
  51. #define NULL       0
  52. #define OPENF      0x0F            /*MSDOS  Open file */
  53. #define CLOSEF     0x10            /*MSDOS  Close file */
  54. #define GETDISK    0x19            /*MSDOS  Current logged in drive */
  55. #define QENTRY     40            /*pritqueue entry size (fcb+2)*/
  56. #define QLASTENTRY 10*QENTRY        /*print queue #entries in bytes*/
  57.  
  58. struct regval{ unsigned int ax,bx,cx,dx,si,di,ds,es;};
  59.  
  60. typedef struct  fcb_t {        /* NON-EXTENDED FCB */
  61.    unsigned char    f_dr;        /* drive code */
  62.    unsigned char    f_name[8],      /* name */
  63.                     f_ext[3];       /* extension */
  64.             int     f_block;        /* current block (=128 records) */
  65.             int     f_recsz;        /* record size in bytes (=1) */
  66.             long    f_size;         /* file size in bytes (system) */
  67.    unsigned int     f_date;         /* modification date (system) */
  68.    unsigned int     f_time;         /* modification time (system) */
  69.             char    f_sys[8];       /* for system use */
  70.    unsigned char    f_rec;          /* current record in block */
  71.    unsigned long    f_seek;         /* random record position */
  72.     } FCB_T, *FCB_PTR;
  73.  
  74. static FCB_T    mfcb_;            /* local file control block */
  75. /****************************************************************************/
  76. spool(fn)    /*trigger off spool print of output file 'fn'*/
  77. char *fn;    /*return 1 if couldn't queue, 0 if done, -1 if error*/
  78. { struct regval srs,srd;
  79.   FCB_PTR buildfcb();
  80.  
  81.   segread(&srs.si);            /* get ds value */
  82.   srs.ax=ADD;
  83.   if((srs.dx=buildfcb(fn))==NULL)return -1;
  84.   sysint(0x2F,&srs,&srd);
  85.   bdos(CLOSEF,&srs.dx);            /*ensure file closed*/
  86.   if(srs.dx!=srd.dx)return srd.ax & 0xff;    /*ok if queue ptr returned*/
  87.   return -1;                /*error, PRINT not installed*/
  88. }
  89. /****************************************************************************/
  90. unspool(fn)    /*cancel spool print of output file 'fn'*/
  91. char *fn;
  92. { struct regval srs,srd;
  93.   FCB_PTR buildfcb();
  94.  
  95.   segread(&srs.si);            /* get ds value */
  96.   srs.ax=CAN;
  97.   if((srs.dx=buildfcb(fn))==NULL)return -1;
  98.   sysint(0x2F,&srs,&srd);
  99.   bdos(CLOSEF,&srs.dx);            /*ensure file closed*/
  100.   if(srs.dx!=srd.dx)return 0;        /*ok if queue ptr returned*/
  101.   return -1;                /*error, PRINT not installed*/
  102. }
  103. /**************************************************************************/
  104.  
  105. qspool(filelist)        /*return number of printing files*/
  106. char filelist[10][13];    /*return queuelist (printing file first)*/
  107.  
  108. { struct regval srs,srd;
  109.   FCB_PTR buildfcb();
  110.   FCB_T retfcb;
  111.   int i;
  112.   char *fp;  setmem(filelist,130,0);
  113.   segread(&srs.si);            /* get ds value */
  114.   srs.ax=QRY;
  115.   srs.dx=0;
  116.   sysint(0x2F,&srs,&srd);
  117.   if(srs.dx==srd.dx)return -1;        /*error, PRINT not installed*/
  118.   if((int)srs.dx==-1)return 0;        /*queue empty*/
  119.   fp=srd.dx;                /*start with current*/
  120.   if(srd.ax>>8)for(i=0;i<10;i++){
  121.     movblock(fp+2,srd.es,&retfcb,srs.ds,sizeof(retfcb));
  122.     if(retfcb.f_dr!=0xff)asciiz(&filelist[i][0],retfcb.f_name);
  123.     fp+=QENTRY;
  124.     if(fp>=srd.bx+QLASTENTRY)fp=srd.bx;
  125.     }
  126.   return srd.ax>>8;
  127. }
  128.  
  129.  
  130. /****************************************************************************/
  131. FCB_PTR buildfcb(rs)            /*Build an open FCB*/
  132. char rs[];
  133. {
  134.   int i,j;
  135.   char  disk;            /* disk specified in run string */
  136.   setmem(&mfcb_,sizeof(mfcb_),0);
  137.   mfcb_.f_dr=bdos(GETDISK,0)+1;        /* default drive code */
  138.   while (strlen(rs) != 0 && rs[0] == ' ') ++rs;
  139.   if (strlen(rs) == 0)return NULL;
  140.   if (rs[1] == ':' && strlen(rs) == 2)return NULL;
  141.   if (rs[1] == ':') {
  142.     disk = toupper(rs[0]) - '@';
  143.     rs += 2;
  144.         }
  145.    else  disk = 0;
  146.   makefn(rs,mfcb_.f_name);
  147.   if(disk)mfcb_.f_dr=disk+1;        /* drive code */
  148.   if(bdos(OPENF,&mfcb_))return &mfcb_;    /* try open */
  149.   return NULL;                /*failed*/
  150. }
  151. /****************************************************************************/
  152. makefn(infn,opfn)         /* ASCIZ -> expanded file name */
  153. char *infn;
  154. char *opfn;
  155. {
  156.   int i, j, swe, swf;
  157.   char temp[13];
  158.   unsigned char c;
  159.  
  160.   strcpy(temp, "           ");
  161.   j = 0;
  162.   swf = swe = TRUE;
  163.   while (swf == TRUE) {
  164.     c = *infn++;
  165.     switch ( c ) {
  166.         case '.' : swf = FALSE;                break;
  167.         case '*' : for (; j < 8; temp[j++] = '?');    break;
  168.  
  169.         case '\0': swf = swe = FALSE;            break;
  170.         default  : if (j < 8) temp[j++] = toupper(c);    break;
  171.         }
  172.     } /* while swf */
  173.   j = 8
  174.  while (swe == TRUE) {
  175.     switch ( c ) {
  176.         case '.' :                     break;
  177.         case '*' : for (; j < 11; temp[j++] = '?');    break;
  178.         case '\0': swe = FALSE;                break;
  179.         default  : if (j < 11) temp[j++] = toupper(c);    break;
  180.         }
  181.     c = *infn++;
  182.     } /* while swe */
  183.   for(i = 0; i < 11;*opfn++ = temp[i++]);
  184.   *opfn = '\0';
  185. } /* makefn() */
  186. /****************************************************************************/
  187. asciiz(fo,fi)                /* convert to ASCIZ filename */
  188. char *fo,fi[];
  189. { int i, j;
  190.   i = 0;
  191.   while (fi[i] != ' ' && i < 8)
  192.       *fo++ = fi[i++];
  193.   *fo++ = '.';
  194.   j = 8;
  195.   while (fi[j] != ' ' && j < 11)
  196.       *fo++ = fi[j++];
  197.   *fo = '\0';
  198. }
  199. tracereg(tag,regs)
  200. char *tag;
  201. struct regval *regs;
  202. { 
  203.   printf("%s regdump ",tag);
  204.   printf("ax=%04x bx=%04x cx=%04x dx=%04x si=%04x di=%04x ds=%04x es=%04x\n",
  205.       regs->ax,regs->bx,regs->cx,regs->dx,regs->si,regs->di,regs->ds,regs->es);
  206. }
  207. tracedump(tag,area,cnt)
  208. unsigned char *tag;
  209. unsigned char area[];
  210. int cnt;
  211. {int i;
  212.   printf("%s dump ",tag);
  213.  for(i=0;i<cnt;printf("%02x",area[i++]));
  214.  printf("\n");
  215. }
  216. rs) != 0 && rs[0] == ' ') ++rs;
  217.   if (strlen(rs) == 0)return N